﻿[["underscore"]] 
module desig
{
    module slice_api
    {
        sequence<byte> ByteArray;
        sequence<short> Int16Array;
        sequence<int> Int32Array;
        sequence<long> Int64Array;
        sequence<float> Float32Array;
        sequence<string> StringArray;

        //设备工作模式
        enum DeviceWorkMode
        {
            Sweep    = 0, //扫频模式
            Fixed    = 1, //定频模式
            Step     = 2, //步进模式
            PlayFile = 3, //文件回放模式
        };

        //控制模式
        enum ControlMode
        {
            kLocal  = 0, //本地控制
            kRemote = 1, //远程控制
        };

        //系统工作模式
        enum SystemWorkMode
        {
            kNormal         = 0, //常规系统模式
            kHighSpeedDemod = 1, //高速解调模式
            kIrSatellite    = 2, //铱星系统模式
            kHQ             = 3, //HQ系统模式
            kEPLRS          = 4, //EPLRS系统模式
            kSINCGARS       = 5, //SINCGARS系统模式
        };
        sequence<SystemWorkMode> SystemWorkModeArray;

        // 数据类型
        enum DataType
        {
            kByte,         //数据类型为 byte
            kShort,        //数据类型为 short
            kFloat,        //数据类型为 float
            kComplexShort, //short类型的IQ
            kComplexFloat, //float类型的IQ
        };
        sequence<DataType> DataTypeArray;

        //数据格式
        enum DataFormat
        {
            kDDC = 0, // DDC数据
            kAD  = 1  // AD数据
        };
        sequence<DataFormat> DataFormatArray;

        //时间（注：由秒计数和纳秒计数组成，该时间计数是基于1970年1月1日UTC时间）
        struct Time
        {
            long second;     //秒计数
            long nanosecond; //纳秒计数
        };

        struct ComplexFloat
        {
            float i;
            float q;
        };
        sequence<ComplexFloat> ComplexFloatArray;

        //卫星信息
        struct SatelliteInfo
        {
            bool enable;         //启用
            long id;             //卫星ID
            string name;         //卫星名称
            string polarization; //卫星极化
            string freq_range;   //卫星频段
        };

        //变频器信息
        struct FreqConverterInfo
        {
            bool enable;  //是否启用
            long rx_freq; //接收频率
            long tx_freq; //发射频率
        };

        // 采集卡信息
        struct DeviceInfo
        {
            string type;          //设备类型
            string serial;        //设备序号
            bool builtin_device;  //内置设备
            string introduction;  //设备详情
            StringArray versions; //版本号（存在多个版本号，与设备有关）
        };
        sequence<DeviceInfo> DeviceInfoArray;

        //频率信息
        struct FrequnecyInfo
        {
            long begin_frequnecy;    //起始频率
            long end_frequnecy;      //结束频率
            long step_bandwidth;     //步进带宽（步进模式或者扫描模式下有效）
            int step_residence_time; //步进驻留时长（步进模式下有效）
        };

        //设备分析频谱存储文件
        struct BroadbandFileInfo
        {
            long frequency;         //频率
            long bandwidth;         //带宽
            long sample_rate;       //采样率
            DataFormat data_format; //数据格式
            Time time;              //文件时间
            string path;            //文件路径
        };
        sequence<BroadbandFileInfo> BroadbandFileInfoArray;

        //消息级别
        enum MessageLevel
        {
            Info = 1,
            Warn = 2,
            Err  = 3,
        };

        //消息
        struct MessageInfo
        {
            MessageLevel level; //消息级别
            string message;     //消息内容
            Time time;          //消息时间
        };
        sequence<MessageInfo> MessageInfoArray;

        //fpga逻辑信息
        struct FPGALogicInfo
        {
            string name;                 //名称
            string guid;                 //ID
            bool exist_high_speed_demod; //存在高速解调
            string description;          //描述信息
        };
        sequence<FPGALogicInfo> FPGALogicInfoArray;

        //范围
        struct Range
        {
            long begin; //起始
            long end;   //结束
        };
        sequence<Range> RangeArray;

        //范围
        struct RangeDouble
        {
            double begin; //起始
            double end;   //结束
        };
        sequence<RangeDouble> RangeDoubleArray;

        //阶
        struct Tier
        {
            bool is_range;    //启用范围
            Range range;      //范围
            Int64Array level; //挡位
        };

        //配置项
        struct SettingInfo
        {
            string name;  //配置项名称
            string value; //配置项内容
        };
        sequence<SettingInfo> SettingInfoArray;

        //组件信息
        struct ComponentInfo
        {
            string guid;                      //GUID
            string name;                      //服务组件名称
            string title;                     //服务组件标签
            string introduction;              //服务组件详情
            string network_ip;                //网络IP地址
            int network_port;                 //网络端口号
            string network_name;              //网络名称
            StringArray support_signal_types; //支持的信号类型
        };
        sequence<ComponentInfo> ComponentInfoArray;

        //列表类型
        enum ListType
        {
            kBlackList  = 0, //黑名单
            kWhiteList  = 1, //白名单
            kKnowSignal = 2, //已知信号
        };

        //列表信息
        struct ListSignalInfo
        {
            string guid;                   //标识
            long frequency;                //频率
            long bandwidth;                //带宽
            string mod_type;               //调制方式
            double symbol_rate;            //符号速率
            double demod_index;            //调制指数
            StringArray feature_sequences; //特征序列集合
            string waveform_id;            //信号波形Id
        };
        sequence<ListSignalInfo> ListSignalInfoArray;

        //列表组信息
        struct ListGroupInfo
        {
            string guid;                            //标识
            string name;                            //组名
            string description;                     //描述信息
        };
        sequence<ListGroupInfo> ListGroupInfoArray; //表示列表组信息集合。

        //列表组
        struct ListGroup
        {
            ListGroupInfo list_group_info;         //列表组信息
            ListSignalInfoArray list_signal_infos; //列表信号信息
        };
        sequence<ListGroup> ListGroupArray;

        //检测库信息
        struct DetectAlgLibraryInfo
        {
            string name;        //名称，唯一标识
            string title;       //显示别名
            string description; //描述信息
            string vision;      //版本号
            string capacity;    //能力标识，如CommoDigital、UFO、3A等对解调库的业务能力标识
            bool authorize;     //授权
            bool is_default;    //默认检测库
        };
        sequence<DetectAlgLibraryInfo> DetectAlgLibraryInfoArray;

        //识别库信息
        struct RecogAlgLibraryInfo
        {
            string name;        //名称，唯一标识
            string title;       //显示别名
            string description; //描述信息
            string vision;      //版本号
            string capacity;    //能力标识，如Commo、UFO、3A等对解调库的业务能力标识
            bool authorize;     //授权
            bool is_default;    //默认检测库
        };
        sequence<RecogAlgLibraryInfo> RecogAlgLibraryInfoArray;

        //解调库信息
        struct DemodAlgLibraryInfo
        {
            string name;        //名称，唯一标识
            string title;       //显示别名
            string description; //描述信息
            string vision;      //版本号
            string capacity;    //能力标识，如CommoDigital、UFO、3A等对解调库的业务能力标识
            bool authorize;     //授权
            bool is_default;    //默认解调库
            int is_special;     //0:通用解调库，1:专用解调库
            int mod_way;        //调制类型：1:数字 2:模拟 3:网台
            int is_mod_index;   //调制指数  0:不支持，1：支持
            int is_demod_eq;    //均衡，0不支持，1支持
        };
        sequence<DemodAlgLibraryInfo> DemodAlgLibraryInfoArray;

        //采集模式
        enum CollectMode
        {
            kContinued       = 0, //持续采集
            kEnergyTrigger   = 1, //能量触发
            kMatchingTrigger = 2, //匹配触发
        };
        //采集优先级
        enum CollectPriority
        {
            kHighest, //最高优先级
            kNormal,  //一般优先级
        };

        //回放状态
        enum PlaybackStatus
        {
            kStop  = 0, //停止状态
            kPlay  = 1, //播放状态
            kPause = 2  //暂停状态
        }
        //回放信息
        struct PlaybackInfo
        {
            bool transmission;  //发射
            long sample_rate;   //采样率
            DataFormat format;  //数据格式
            DataType data_type; //数据类型
            StringArray files;  //文件
        }
        //文件回放进度
        struct PlaybackProgress
        {
            string file;       //文件
            long sample_count; //文件样点数
            long sample_index; //样点位置
        };

        //识别信息
        struct RecogInfo
        {
            bool enable;                 //启用识别
            bool authorize;              //授权（与识别库有关）
            bool general_recog;          //通用识别
            double demod_index;          //调制指数
            double symbol_rate;          //符号速率
            bool enable_freqs;           //启用频点集合
            bool enable_freq_bands;      //启用频段集合
            bool enable_bandwidths;      //启用带宽范围集合
            string recognition_library;  //识别库
            Int64Array freqs;            //频点集合
            RangeArray freq_bands;       //频段集合
            RangeArray bandwidths;       //带宽范围集合
            StringArray match_sequences; //特征序列集合
        };

        //控守信息
        struct CollectInfo
        {
            bool enable;                      //启用控守
            bool enable_channel;              //启用通道
            bool enable_storage;              //启用存储
            bool enable_push_component;       //启用推送组件
            int energy_threshold;             //能量门限（单位：db 仅能量触发模式有效）
            int energy_timeout_duration;      //能量超时时长（单位：s 仅能量触发模式有效）
            DataFormat collect_data_format;   //采集数据格式
            CollectMode collect_mode;         //采集模式
            CollectPriority collect_priority; //采集优先级
        };

        //解调信息
        struct DemodulationInfo
        {
            bool enable;                 //启用解调
            bool authorize;              //授权（与解调库有关）
            string demodulation_library; //解调库名称
        };

        //波形信息
        struct WaveformInfo
        {
            string guid;                        //唯一标识
            string name;                        //显示名称
            string group_name;                  //分组名称
            string system_type;                 //体制类型
            string modulation_type;             //调制类型
            string carrier_type;                //载波类型
            string symbol_rate;                 //符号速率
            string demod_index;                 //调制指数
            string description;                 //描述信息
            long channel_bandwidth;             //信道带宽
            long channel_sample_rate;           //信道采样率
            bool is_default;                    //默认波形(内置波形)
            RecogInfo recog_info;               //识别信息
            CollectInfo collect_info;           //控守信息
            DemodulationInfo demodulation_info; //解调信息
        };
        sequence<WaveformInfo> WaveformInfoArray;

        //频谱数据包
        struct SpectrumPacket
        {
            DeviceWorkMode work_mode; //工作模式
            int series;               //数据批次序列号
            int order;                //频谱阶数
            int smooth_times;         //平滑次数
            long frequnecy;           //中心频率
            long bandwidth;           //带宽
            long sample_rate;         //采样率
            int frame_size;           //每帧大小
            int frame_count;          //当前帧数量
            Time time;                //数据起始时间
            Float32Array datas;       //幅度数据
        };
        sequence<SpectrumPacket> SpectrumPackets;

        //模拟解调输出数据包
        struct AnalogPacket
        {
            int series;       //数据批次序列号
            long sample_rate; //数据采样率
            Time time;        //时间起始
            Int16Array datas; //波形数据
        };

        //数字解调符号数据包
        struct SymbolPacket
        {
            int series;         //数据批次序列号
            int symbol_order;   //符号阶数
            double symbol_rate; //符号速率
            Time time;          //时间起始
            ByteArray datas;    //符号数据
        };

        //数字解调星座数据包
        struct ConstelPacket
        {
            int series;         //数据批次序列号
            int max_value;      //数据最大值
            int min_value;      //数据最小值
            float est_ber;      //星座误码估计值
            float rms_evm;      //星座均方根EVM
            float ebn0;         //星座EbN0估计值
            Float32Array datas; //星座数据（每两个数据表示一个星座点）
        };
        sequence<ConstelPacket> ConstelPacketArray;

        //眼图数据包
        struct EyePacket
        {
            int series;         //数据批次序列号
            int max_value;      //数据最大值
            int min_value;      //数据最小值
            int frame_length;   //帧长
            Float32Array datas; //眼图数据（每两个数据表示一个星座点）
        };

        //窄带通道信息
        struct NarrowbandChannelInfo
        {
            int wb_id;                    //宽带通道号
            int channel_id;               //通道号
            Tier ad_sample_rates;         //通道支持的ad采样率
            Tier ddc_sample_rates;        //通道支持的ddc采样率
            DataFormatArray data_formats; //通道支持的数据格式
        };
        sequence<NarrowbandChannelInfo> NarrowbandChannelInfoArray;

        //分析频谱信息
        struct AnalySpecInfo
        {
            Int32Array fft_orders;       //频谱阶数档位
            Int32Array fft_smooth_times; // 频谱平滑次数档位
        };

        enum GainMode
        {
            kNormal   = 0, //常规增益模式
            kLowNoise = 1, //低噪声增益模式
        };
        sequence<GainMode> GainModeArray;

        enum GainControlType
        {
            kAGC = 0, //自动增益控制
            kMGC = 1, //手动增益控制
        };
        sequence<GainControlType> GainControlTypeArray;

        // 工作模式信息
        struct WorkModeInfo
        {
            DeviceWorkMode work_mode;                        //工作模式
            bool support_digital_gain;                       //支持数字增益
            bool support_level;                              //支持电平
            bool support_gain;                               //支持增益
            bool support_transmission;                       //支持发射
            bool support_transmission_gain;                  //支持发射增益

            Tier bandwidths;                                 //带宽集合
            Tier sample_rates;                               //采样率集合

            Float32Array normal_gains;                       //常规增益档位
            Float32Array low_noise_gains;                    //低噪声增益档位
            Float32Array digital_gains;                      //数字增益档位
            Float32Array level_gains;                        //电平增益档位
            Float32Array transmission_gains;                 //发射增益档位

            GainModeArray support_gain_modes;                //支持的增益模式类型
            GainControlTypeArray support_gain_control_types; //支持的增益控制类型
            Int32Array fft_order_array;                      //频谱阶数档位
            Int32Array smooth_time_array;                    //频谱平滑次数档位
            Tier real_data_playback_fs_array;                //文件回放实信号采样率挡位（仅回放模式下有效）
            Tier complex_data_playback_fs_array;             //文件回放复信号采样率挡位（仅回放模式下有效）
            DataTypeArray support_playback_data_type;        //支持的回放数据类型（仅回放模式下有效）
            DataFormatArray support_playback_data_format;    //支持的回放数据格式（仅回放模式下有效）
            DataFormatArray support_broadband_data_format;   //支持的宽带采集数据格式
        };
        sequence<WorkModeInfo> WorkModeInfoArray;

        // 宽带通道信息
        struct BroadbandChannelInfo
        {
            int wb_id;                         //通道号
            bool enable;                       //启用
            bool support_invert_spectrum;      //支持倒频
            Range freq_range;                  //频率范围
            WorkModeInfoArray work_mode_infos; //工作模式信息
        };
        sequence<BroadbandChannelInfo> BroadbandChannelInfoArray;

        // 解调模式
        enum HighSpeedDemodulationMode
        {
            kNormal, //常规解调
            kOFDM,   //ofdm解调
        };
        sequence<HighSpeedDemodulationMode> HighSpeedDemodulationModeArray;

        // 调制类型信息
        struct ModulationType
        {
            string modulation_type;                         //调制类型
            bool enable_modulation_index;                   //启用调制指数
            RangeDouble modulation_index_range;             //调制指数范围
            RangeDouble modulation_rate_range;              //调制速率范围
            ComplexFloatArray constellation_mapping_points; //星座映射点
        };
        sequence<ModulationType> ModulationTypeArray;

        // 常规调制解调
        struct NormalDemodulationInfo
        {
            ModulationTypeArray modulation_types;
        };

        // OFDM信号解调
        struct OFDMDemodulationInfo
        {
            ModulationTypeArray data_modulation_types;  //数据支持的调制类型
            ModulationTypeArray pilot_modulation_types; //导频支持的调制类型
        };

        // 高速解调通道信息
        struct HighSpeedDemodChannelInfo
        {
            int wb_id;                                         //宽带通道号(-1 所有宽带通道均可使用)
            int channel_id;                                    //通道号
            HighSpeedDemodulationModeArray demodulation_modes; //支持的高速解调模式
            NormalDemodulationInfo normal_demod_info;          //常规高速解调信号信息
            OFDMDemodulationInfo ofdm_demod_info;              //ofdm高速解调信号信息
        };
        sequence<HighSpeedDemodChannelInfo> HighSpeedDemodChannelInfoArray;

        // 设备窄带信息
        struct DeviceNarrowbandSettings
        {
            NarrowbandChannelInfoArray collect_channel_infos;              //ddc通道信息数组
            NarrowbandChannelInfoArray analysis_channel_infos;             //分析通道信息数组
            NarrowbandChannelInfoArray recog_channel_infos;                //识别通道信息数组
            NarrowbandChannelInfoArray demod_channel_infos;                //解调通道信息数组
            HighSpeedDemodChannelInfoArray high_speed_demod_channel_infos; //高速解调通道信息数组
        };

        // 设备设置信息
        struct DeviceSettings
        {
            string type;                                       //设备类型
            string serial;                                     //设备序号
            bool builtin_device;                               //内置设备
            string introduction;                               //设备详情
            StringArray versions;                              //版本号（存在多个版本号，与设备有关）

            long device_type;                                  //设备类型
            long rf_step_freq;                                 //射频步进频率
            bool supports_reloading;                           //支持重加载
            bool supports_changing_rf_input;                   //支持更改射频输入

            AnalySpecInfo analy_spec_channel_info;             //分析频谱通道信息

            FPGALogicInfoArray fpga_logic_infos;               //fpga逻辑信息（仅支持fpga重加载下有效）
            BroadbandChannelInfoArray broadband_channel_infos; //宽带通道信息
        };

        //频谱信息
        struct SpectrumInfo
        {
            int fft_order;    //频谱FFT秩
            int smooth_times; //频谱平滑次数
        };

        //存储模式
        enum StorageMode
        {
            kContinue  = 0, //持续存储
            kFixedSize = 1, //固定字节存储
            kFixedTime = 2, //固定时长存储
        };

        //数据存储信息
        struct DataStorageInfo
        {
            StorageMode mode; //存储模式
            long size;        //采集数据大小
        };

        //频谱数据存储信息
        struct SpectrumStorageInfo
        {
            DataStorageInfo info; //数据存储信息
            int duration;         //采集数据时间间隔（采集一帧频谱数据的间隔）
        };

        //数据存储进度
        struct DataStoreProgress
        {
            double duration;  //存储持续时间，以秒为单位
            long total_bytes; //总共存储字节数
        };

        //频谱信号信息
        struct SpectrumSignalInfo
        {
            long frequnecy; //中心频率
            long bandwidth; //带宽
            float cnr;      //载噪比
            float level;    //电平功率
        };
        sequence<SpectrumSignalInfo> SpectrumSignalInfoArray;

        //识别模式
        enum DetectRecogMode
        {
            kOnlyDetect     = 0, //仅检测
            kOnlyRecog      = 1, //指定载波识别
            kConditionRecog = 2, //重点信号识别
            kSmartRecog     = 3, //智能检测识别
        };

        // 识别阶段
        enum RecognitionPhase
        {
            kSignalRecognition = 0, //信号识别
            kCodeRecognition   = 1, //译码识别
            kSourceRecognition = 2, //信源识别
        };

        //检测识别信息
        struct DetectRecogInfo
        {
            DetectRecogMode mode;          //检测识别模式
            Range detect_freq_range;       //检测频率范围
            bool enable_black_list;        //启用黑名单
            bool enable_white_list;        //启用白名单
            RecognitionPhase phase;        //识别阶段
            StringArray black_list_groups; //黑名单组
            StringArray white_list_groups; //白名单组
            StringArray waveform_ids;      //识别波形-GUID集合
        };

        //检测识别信号信息
        struct DetectRecogSignal
        {
            string guid;              //检出信号的唯一识别ID
            long frequnecy;           //信号中心频率，单位Hz
            long bandwidth;           //信号带宽，单位Hz
            int detect_count;         //检测次数
            Time first_detect_time;   //首次检出时间
            Time current_detect_time; //最新检出时间
            float cnr;                //载噪比
            float level;              //电平值
            bool disappear;           //出联状态
            bool whitelist_alert;     //白名单告警
        };
        //检出识别信号集合
        sequence<DetectRecogSignal> DetectRecogSignalArray;

        struct SignalFreqOffsetInfo
        {
            double freq_offset; // 频偏
            Time data_time;     // 数据时间
        };
        sequence<SignalFreqOffsetInfo> SignalFreqOffsetInfoArray;

        //检测识别信号状态
        struct DetectRecogSignalState
        {
            string guid;                                 //检出信号的唯一识别ID
            string waveform_id;                          //识别信号波形Id,可为空
            long frequnecy;                              //信号中心频率，单位Hz(精估)
            long bandwidth;                              //信号带宽，单位Hz(精估)
            string system_type;                          //体制类型
            string signal_type;                          //信号类型
            string mod_type;                             //调制类型
            string carrier_type;                         //载波类型
            double symbol_rate;                          //符号速率
            double mod_index;                            //调制指数
            double confidence;                           //置信度
            bool whitelist_alert;                        //白名单告警

            string code_type;                            //编码方式
            string code_rate;                            //编码速率
            string scramble_type;                        //扰码类型
            string scramble_poly;                        //扰码多项式
            string interleave_type;                      //交织方式
            string frame_type;                           //帧格式
            string frame_info_rate;                      //帧长
            string source_type;                          //信源类型
            string platform_info;                        //频台属性
            Float32Array evm;                            //解调evm
            Float32Array ebn0;                           //解调ebn0
            Float32Array err_bers;                       //解调误码率
            ConstelPacketArray constel_packets;          //星座数据
            SignalFreqOffsetInfoArray freq_offset_infos; //频偏信息
        };
        sequence<DetectRecogSignalState> DetectRecogSignalStateArray;

        //来源
        enum FromType
        {
            kManualAddition = 0, //手动添加
            kWhiteList      = 1, //白名单
            kAutoGuidance   = 2, //自动引导
        };

        struct CollectSignalStatus
        {
            string guid;
            bool worker;
            bool storage;
        };
        sequence<CollectSignalStatus> CollectSignalStatusArray;

        //信道化采集通道信息
        struct CollectSignal
        {
            string guid;                       //信号的唯一识别ID
            FromType from_type;                //来源
            DeviceWorkMode from_work_mode;     //来源工作模式
            int file_index;                    //文件序号
            int channel_id;                    //窄带通道Id
            long frequnecy;                    //信号中心频率，单位Hz
            long bandwidth;                    //信号带宽，单位Hz
            long sample_rate;                  //信号采样率
            string waveform_id;                //信号波形Id
            string system_type;                //体制类型
            string signal_type;                //信号类型
            string carrier_type;               //载波类型
            string mod_type;                   //调制类型
            double symbol_rate;                //符号速率
            double mod_index;                  //调制指数
            int energy_threshold;              //能量触发门限(仅能量触发采集模式有效)
            int energy_timeout_duration;       //能量触发超时时长(仅能量触发采集模式有效)
            CollectPriority priority;          //控守优先级
            CollectMode collect_mode;          //采集模式
            DataFormat collect_data_format;    //采集数据格式
            StringArray component_guids;       //处理服务组件guid
            bool custom_sampling_rate_enabled; //启用自定义采集采样率
            long custom_sampling_rate;         //自定义采集采样率
        };
        sequence<CollectSignal> CollectSignalArray;

        //分析频谱数据包
        struct AnalysisSpectrumPacket
        {
            int order;          //阶数
            int fft_order;      //频谱阶数
            int smooth_times;   //平滑次数
            long frequnecy;     //中心频率
            long bandwidth;     //带宽
            long sample_rate;   //采样率
            int frame_size;     //每帧大小
            int frame_count;    //当前帧数量
            Time time;          //数据起始时间
            Float32Array datas; //数据
        };
        sequence<AnalysisSpectrumPacket> AnalysisSpectrumPackets;

        //分析信息
        struct AnalysisInfo
        {
            int channel_id;         //通道号
            long frequency;         //通道频率
            long bandwidth;         //通道带宽
            long sample_rate;       //通道采样率
            DataFormat data_format; //数据格式
        };

        //分析频谱测量结果
        struct AnalysisMeasureResult
        {
            int order;                     //测量频谱阶数
            long frequency;                //测量中心频率
            long bandwidth;                //测量信号带宽
            long symbol_rate;              //测量符号速率
            Int32Array frequency_points;   //测量中频的点信息
            Int32Array symbol_rate_points; //测量的符号速率点信息
        };

        //分析识别结果
        struct AnalysisRecogResult
        {
            long frequency;   //频率
            long symbol_rate; //符号速率
            long bandwidth;   //带宽
            string mod_type;  //调制方式
            double mod_index; //调制指数
            double conf;      //置信度
        };

        //解调信息
        struct DemodInfo
        {
            int channel_id;   //通道号
            long frequency;   //频率
            long bandwidth;   //带宽
            long symbol_rate; //符号速率
            string mod_type;  //调制方式
            double mod_index; //调制指数
            bool demod_eq;    //是否解调均衡
            string demod_lib; //调制方式
        };

        // 比特图信息
        struct BitstreamInfo
        {
            int data_len;   //数据长度
            ByteArray data; //数据
        };

        // 星座图信息
        struct ConstellationDiagramInfo
        {
            Range data_range;  //数据范围
            float ebn0;        //当前星座EbN0估计值
            float evm;         //当前星座均方根EVM
            float err_bar;     //当前星座误码估计值
            int data_len;      //数据长度
            Float32Array data; //星座数据（每两个数据表示一个星座点）
        };

        // 相位信息
        struct PhaseInfo
        {
            Time begin_time;   //起始时间
            Time end_time;     //结束时间
            long frame_size;   //帧长
            Float32Array data; //数据
        };

        // 信号质量
        struct SignalQualityInfo
        {
            float atomic_offset;    //原子偏移
            float gain_balance;     //增益平衡
            long ccdf_data_len;     //ccdf数据长度
            Float32Array ccdf_data; //ccdf数据
            long pdf_data_len;      //pdf数据长度
            Float32Array pdf_data;  //pdf数据
        };

        // 星座映射类型
        enum ConstellationMappingType
        {
            kGrayCode,          //格雷码
            kNaturalBinaryCode, //自然码
            kCustom,            //自定义
        };
        // 星座映射
        struct ConstellationMapping
        {
            ConstellationMappingType type; //星座映射类型
            Int32Array code_bits;          //编码比特
        };
        // 块状
        struct BlockLike
        {
            int start_symbol_position; //起始符号位置
            int pilot_symbol_position; //导频符号数量
            int pilot_symbol_interval; //导频符号间隔
        };
        // 梳状
        struct CombLike
        {
            int start_subcarrier_position; //起始子载波位置
            int pilot_subcarrier_count;    //导频子载波数量
            int pilot_subcarrier_interval; //导频子载波间隔
        };

        // 混合状
        struct HybridLike
        {
            int start_subcarrier_position;        //起始子载波位置
            int pilot_subcarrier_count;           //导频子载波数量
            int pilot_subcarrier_interval;        //导频子载波间隔
            int start_subcarrier_position_offset; //导频子载波位置偏移
        };

        //导频子载波插入方式
        enum PilotInsertionType
        {
            kBlockLike, //块状
            kCombLike,  //梳状
            kHybridLike //混合状
        };

        struct NormalDemodInfo
        {
            string mod_type;                       //调制类型
            double mod_rate;                       //调制速率
            double mod_index;                      //调制指数（-1表示无效）
            int mod_order;                         //调制阶数
            ConstellationMapping mod_constell_map; //星座映射
        };

        // OFDM解调信息
        struct OFDMDemodInfo
        {
            int carrier_count;                           //载波数量
            int carrier_inv;                             //载波间隔
            int valid_carrier_count;                     //有效载波数量
            int valid_carrier_start_pos;                 //有效载波起始位置
            int frame_per_symbol;                        //一帧的符号数
            double cyclic_prefix_ratio;                  //循环前缀比列(0-1 6位小数)
            string sync_sequence;                        //同步训练序列
            int sync_sequence_count;                     //同步训练序列个数

            string data_mod_type;                        //数据载波调制类型
            double data_mod_rate;                        //数据载波调制速率
            double data_mod_index;                       //数据载波调制指数（-1表示无效）
            int data_mod_order;                          //数据载波调制阶数
            ConstellationMapping data_mod_constell_map;  //数据载波星座映射

            string pilot_mod_type;                       //导频调制方式
            double pilot_mod_rate;                       //调制速率
            double pilot_mod_index;                      //调制指数（-1表示无效）
            int pilot_mod_order;                         //调制阶数
            int pilot_symbol_value;                      //导频符号值
            ConstellationMapping pilot_mod_constell_map; //导频的星座映射

            PilotInsertionType insertion_type;           //导频载波插入方式
            BlockLike block_like;                        //块状(与导频子载波插入类型相关)
            CombLike comb_like;                          //梳状(与导频子载波插入类型相关)
            HybridLike hybrid_like;                      //混合状(与导频子载波插入类型相关)
            ByteArray custom_pilot_pos_list;             //自定义导频插入位置
        };

        // 高速解调参数
        struct HighSpeedDemodInfo
        {
            int wb_id;                            //宽带通道号
            long frequency;                       //频率
            HighSpeedDemodulationMode demod_mode; //解调模式
            NormalDemodInfo normal_demod_info;    //常规解调信息
            OFDMDemodInfo ofdm_demod_info;        //ofdm解调信息
        };

        //任务运行状态
        enum TaskStatus
        {
            kStop    = 0, //停止状态
            kRunning = 1, //执行状态
            kWaiting = 2  //等待状态
        };

        // 任务控制参数
        struct TaskControlInfo
        {
            int wb_id;                                 //宽带通道
            DeviceWorkMode work_mode;                  //工作模式
            FrequnecyInfo frequnecy_info;              //频率信息
            bool enable_broadband_collect;             //启动宽带采集
            DataFormat data_format;                    //数据格式
            DataStorageInfo broadband_storage_info;    //宽带数据存储信息
            bool enable_spectrum_collect;              //启动频谱采集
            SpectrumStorageInfo spectrum_storage_info; //频谱数据存储信息
            bool enable_gain;                          //启用增益
            GainControlType gain_control_type;         //增益控制类型
            GainMode gain_mode;                        //增益模式类型
            float gain;                                //增益
            bool enable_digital_gain;                  //启用数字增益
            float digital_gain;                        //数字增益
            bool enable_level;                         //启用电平
            float level;                               //电平
            bool enable_transmission_gain;             //启用发射增益
            float transmission_gain;                   //发射增益
            FreqConverterInfo freq_converter_info;     //变频器信息
            SatelliteInfo satellite_info;              //卫星信息
            SpectrumInfo spectrum_info;                //设备显示频谱参数
            bool enable_detect_recog;                  //启动检测识别
            DetectRecogInfo detect_recog_info;         //检测识别参数
        };
        sequence<TaskControlInfo> TaskControlInfoArray;

        //任务信息
        struct TaskInfo
        {
            string guid;                             // guid
            string name;                             // 名称
            long task_id;                            // 任务号
            Time begin_time;                         //启动时间
            Time end_time;                           //启动时间
            TaskControlInfoArray task_control_infos; //任务控制参数
        };
        sequence<TaskInfo> TaskInfoArray;
    }
}